"use strict";
/**
 * Electron预加载脚本 - TypeScript版本
 * 本文件在渲染进程加载前执行，用于在渲染进程和主进程之间建立安全的通信桥梁
 * 通过contextBridge.exposeInMainWorld方法将经过安全验证的API暴露给渲染进程
 */
Object.defineProperty(exports, "__esModule", { value: true });
// 导入所需模块
var electron_1 = require("electron");
console.log('预加载脚本已加载');
/**
 * 渲染进程可调用的Electron API集合
 * 提供经过安全验证的IPC通信方法
 */
var electronAPI = {
    /**
     * 发送消息到主进程
     * @param channel - 消息通道名称
     * @param data - 要发送的数据
     */
    sendMessage: function (channel, data) {
        var validChannels = ['ping', 'login-success'];
        if (validChannels.includes(channel)) {
            console.log('preload -> 发送 IPC 消息:', channel, data);
            electron_1.ipcRenderer.send(channel, data);
        }
    },
    /**
     * 监听并接收来自主进程的消息
     * @param channel - 消息通道名称
     * @param func - 接收到消息时的回调函数
     */
    receiveMessage: function (channel, func) {
        var validChannels = ['pong'];
        if (validChannels.includes(channel)) {
            // 监听事件
            electron_1.ipcRenderer.on(channel, function (_event) {
                var args = [];
                for (var _i = 1; _i < arguments.length; _i++) {
                    args[_i - 1] = arguments[_i];
                }
                return func.apply(void 0, args);
            });
        }
    },
    /**
     * 通知主进程用户已登录成功
     */
    loginSuccess: function () {
        console.log('登录成功，通知主进程');
        electron_1.ipcRenderer.send('login-success');
    },
    /**
     * 退出登录
     */
    exitLogin: function () {
        console.log('退出登录，通知主进程');
        electron_1.ipcRenderer.send('exit-login');
    },
    /**
     * 打开添加好友窗口
     */
    openAddUserWindow: function () {
        console.log('打开添加好友窗口，通知主进程');
        electron_1.ipcRenderer.send('open-add-user-window');
    },
    /**
     * 打开好友申请窗口
     */
    openFriendRequestWindow: function () {
        console.log('打开好友申请窗口，通知主进程');
        electron_1.ipcRenderer.send('open-friend-request-window');
    },
    /**
     * 刷新好友申请列表
     */
    friendRequestUpdated: function () {
        console.log('刷新好友申请列表，通知主进程');
        electron_1.ipcRenderer.invoke('friend-request-updated');
    },
    /**
     * 监听好友申请列表更新
     */
    onFriendRequestUpdate: function (callback) {
        console.log('注册好友申请列表更新监听');
        electron_1.ipcRenderer.on('friend-request-refresh', function (_event, data) {
            console.log('收到好友申请列表更新:', data);
            callback(data);
        });
    },
    /**
     * 检查API是否可用
     * @returns 始终返回true
     */
    isAvailable: function () { return true; },
    /**
     * 通过主进程代理发送WebSocket消息
     */
    wsSend: function (data) {
        console.log('preload -> 通过IPC发送WebSocket消息:', data);
        return electron_1.ipcRenderer.invoke('ws-send', data);
    },
    /**
     * 检查WebSocket连接状态
     */
    wsGetStatus: function () {
        console.log('通过IPC获取WebSocket状态');
        return electron_1.ipcRenderer.invoke('ws-get-status');
    },
    /**
     * 初始化WebSocket连接
     */
    wsInit: function (userId, url) {
        console.log('通过IPC初始化WebSocket:', { userId: userId, url: url });
        return electron_1.ipcRenderer.invoke('ws-init', { userId: userId, url: url });
    },
    /**
     * 断开WebSocket连接
     */
    wsDisconnect: function () {
        console.log('通过IPC断开WebSocket连接');
        return electron_1.ipcRenderer.invoke('ws-disconnect');
    },
    /**
     * 监听WebSocket状态变化
     */
    onWsStatusChange: function (callback) {
        console.log('注册全局WebSocket状态监听');
        electron_1.ipcRenderer.on('ws-status-change', function (_event, status) {
            console.log('收到WebSocket状态变化:', status);
            callback(status);
        });
    },
    /**
     * 监听WebSocket消息
     */
    onWsMessage: function (callback) {
        console.log('注册全局WebSocket消息监听');
        electron_1.ipcRenderer.on('ws-message', function (_event, data) {
            console.log('收到WebSocket消息:', data);
            callback(data);
        });
    },
    /**
     * 移除WebSocket消息监听
     */
    offWsMessage: function (callback) {
        console.log('移除全局WebSocket消息监听');
        electron_1.ipcRenderer.off('ws-message', callback);
    },
    /**
     * 操作应用程序配置存储
     */
    store: {
        set: function (key, value) { return electron_1.ipcRenderer.invoke('store-set', key, value); },
        get: function (key) { return electron_1.ipcRenderer.invoke('store-get', key); },
        delete: function (key) { return electron_1.ipcRenderer.invoke('store-delete', key); }
    },
    /**
     * 数据库操作接口
     * 通过IPC与主进程通信，安全地执行数据库操作
     */
    database: {
        // 初始化数据表
        initTables: function () { return electron_1.ipcRenderer.invoke('database-init-tables'); },
        // 消息相关
        addMessage: function (message) {
            return electron_1.ipcRenderer.invoke('database-add-message', message);
        },
        updateMessageStatus: function (local_id, status) {
            return electron_1.ipcRenderer.invoke('database-update-message-status', local_id, status);
        },
        getMessagesByConversation: function (conversationId, limit) {
            if (limit === void 0) { limit = 30; }
            return electron_1.ipcRenderer.invoke('database-get-messages', conversationId, limit);
        },
        // 好友申请相关
        addFriendRequest: function (friendRequest) {
            return electron_1.ipcRenderer.invoke('database-add-friend-request', friendRequest);
        },
        getFriendRequestsByToUserId: function (toUserId, status) {
            return electron_1.ipcRenderer.invoke('database-get-friend-requests-by-to-user-id', toUserId, status);
        },
        // 更新好友申请状态
        updateFriendRequestStatus: function (id, status) {
            return electron_1.ipcRenderer.invoke('database-update-friend-request-status', id, status);
        },
        // 关闭数据库
        close: function () { return electron_1.ipcRenderer.invoke('database-close'); }
    }
};
/**
 * 将定义的API暴露到渲染进程的全局作用域
 * 使用try-catch块确保即使注入失败也不会中断应用运行
 */
// 标记注入状态
var injectionSuccessful = false;
// 根据 contextIsolation 状态选择注入方式
if (process.contextIsolated) {
    // 上下文隔离启用时使用 contextBridge
    try {
        // 暴露electronAPI
        electron_1.contextBridge.exposeInMainWorld('electronAPI', electronAPI);
        // 暴露一个标志，用于前端检测Electron环境
        electron_1.contextBridge.exposeInMainWorld('__electron_preload_loaded', true);
        injectionSuccessful = true;
        console.log('✅ electronAPI 通过 contextBridge 注入成功');
        console.log('✅ __electron_preload_loaded 标志已设置');
        // 立即验证注入是否成功
        // 注意：由于contextBridge的工作机制，这里不能直接访问window.electronAPI
        // 但我们可以确认注入过程没有抛出异常
        console.log('✅ 注入过程完成，注入状态标记为成功');
    }
    catch (error) {
        console.error('❌ electronAPI 注入失败:', error);
        injectionSuccessful = false;
    }
}
else {
    // 上下文隔离禁用时直接挂载
    try {
        window.electronAPI = electronAPI;
        window.__electron_preload_loaded = true;
        injectionSuccessful = true;
        console.log('✅ electronAPI 直接挂载成功');
        console.log('✅ __electron_preload_loaded 标志已设置');
        // 立即验证挂载是否成功
        console.log('✅ 立即验证 electronAPI 可用:', !!window.electronAPI);
    }
    catch (error) {
        console.error('❌ electronAPI 挂载失败:', error);
        injectionSuccessful = false;
    }
}
/**
 * 监听DOM内容加载完成事件
 * 确保在DOM完全加载后再执行后续操作
 */
window.addEventListener('DOMContentLoaded', function () {
    console.log('🌐 DOM 加载完成');
    // 检查electronAPI是否可用
    // 注意：当启用contextIsolation时，我们不能直接在预加载脚本中访问window.electronAPI
    // 所以我们使用注入状态标志来表示是否成功注入
    var electronApiAvailable = process.contextIsolated
        ? injectionSuccessful
        : !!window.electronAPI;
    console.log('🔍 electronAPI 可用:', electronApiAvailable);
    console.log('🔍 注入状态标志:', injectionSuccessful);
    console.log('🔍 上下文隔离状态:', process.contextIsolated);
    // 发送事件通知 Vue 组件 API 已就绪
    window.dispatchEvent(new Event('electron-api-ready'));
});
// 添加一个函数，用于在渲染进程中验证API是否正确暴露
if (!process.contextIsolated) {
    window.validateElectronAPI = function () {
        var _a;
        console.log('📋 electronAPI 验证结果:', {
            exists: !!window.electronAPI,
            methods: window.electronAPI ? Object.keys(window.electronAPI) : [],
            isAvailableWorks: ((_a = window.electronAPI) === null || _a === void 0 ? void 0 : _a.isAvailable)
                ? window.electronAPI.isAvailable()
                : false
        });
        return !!window.electronAPI;
    };
}
